{"cells":[{"cell_type":"markdown","metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5"},"source":["#  &#x1F4D1; **作业 14: 终生机器学习 `LifeLong Machine Learning`**\n","### 助教的PPT\n","[PPT](https://docs.google.com/presentation/d/1SMJLWPTPCIrZdNdAjrS4zQZx1kfB73jCFSb7JRX90gQ/edit?usp=sharing)\n","\n","- 终生学习的定义\n","  - 关于终身学习的详细解释和定义，请参阅 [LifeLong learning | youtu.be](https://youtu.be/7qT5P9KJnWo) \n","\n","- 终生学习的一些方法\n","  - 有人在2019年底为LifeLong Learning提出了一份调查论文，将2016-2019年的LigeLong学习方法分为三个家族。\n","依据任务数据信息在整个学习过程中的存储和使用方式的差异，可以将LifeLong学习方法分为三类：\n","    * 基于重采样的方法   `Replay-based methods`\n","    * 基于正则化的方法  `Regularization-based methods`\n","    * 参数隔离方法      `Parameter isolation methods`\n","\n","![LL_summary](./HW14_pic/LLL_summary.png)\n","\n","在本次作业中，我们关注**基于正则化的方法**中的`prior-focused`方法: **EWC、MAS、SI、Remanian Walk、SCP**\n","\n","\n","\n","论文: [Continual Learning in Neural\n","Networks](https://arxiv.org/pdf/1910.02718.pdf)\n","\n","如果您有任何问题，请随时给我们发邮件。[ntu-ml-2022spring-ta@googlegroups.com](ntu-ml-2022spring-ta@googlegroups.com)"]},{"cell_type":"markdown","metadata":{"execution":{"iopub.execute_input":"2023-07-12T08:38:36.197928Z","iopub.status.busy":"2023-07-12T08:38:36.197446Z","iopub.status.idle":"2023-07-12T08:38:36.225100Z","shell.execute_reply":"2023-07-12T08:38:36.224195Z","shell.execute_reply.started":"2023-07-12T08:38:36.197870Z"}},"source":["# 导入包"]},{"cell_type":"code","execution_count":1,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:19:24.197945Z","iopub.status.busy":"2023-07-19T13:19:24.197543Z","iopub.status.idle":"2023-07-19T13:19:28.462649Z","shell.execute_reply":"2023-07-19T13:19:28.456405Z","shell.execute_reply.started":"2023-07-19T13:19:24.197908Z"},"trusted":true},"outputs":[],"source":["import argparse\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import os\n","import torch\n","import torch.utils.data as data\n","from torch.utils.data import DataLoader\n","import torch.utils.data.sampler as sampler\n","import torch.nn as nn\n","import torch.nn.functional as F\n","import torchvision\n","from torchvision import datasets, transforms\n","from tqdm.auto import tqdm\n","import random"]},{"cell_type":"code","execution_count":2,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:19:28.465604Z","iopub.status.busy":"2023-07-19T13:19:28.464664Z","iopub.status.idle":"2023-07-19T13:19:29.705962Z","shell.execute_reply":"2023-07-19T13:19:29.704664Z","shell.execute_reply.started":"2023-07-19T13:19:28.465568Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Wed Jul 19 13:19:29 2023       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 470.161.03   Driver Version: 470.161.03   CUDA Version: 11.4     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   34C    P0    27W / 250W |      0MiB / 16280MiB |      0%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":3,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:07.181622Z","iopub.status.busy":"2023-07-19T13:22:07.181249Z","iopub.status.idle":"2023-07-19T13:22:07.224548Z","shell.execute_reply":"2023-07-19T13:22:07.223509Z","shell.execute_reply.started":"2023-07-19T13:22:07.181589Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Set env random_seed = 0\n"]}],"source":["def all_seed(seed=6666, env=None):\n","    if env is not None:\n","        env.seed(seed)\n","        env.action_space.seed(seed)\n","    np.random.seed(seed)\n","    random.seed(seed)\n","    # CPU\n","    torch.manual_seed(seed)\n","    # GPU\n","    if torch.cuda.is_available():\n","        torch.cuda.manual_seed_all(seed)\n","        torch.cuda.manual_seed(seed)\n","    # python全局\n","    os.environ['PYTHONHASHSEED'] = str(seed)\n","    # cudnn\n","    torch.backends.cudnn.deterministic = True\n","    torch.backends.cudnn.benchmark = False\n","    torch.backends.cudnn.enabled = False\n","    print(f'Set env random_seed = {seed}')\n","\n","all_seed(0)"]},{"cell_type":"markdown","metadata":{},"source":["# 数据准备\n","\n","我们使用旋转的手写识别数据集MNIST(`rotated MNIST`) 作为训练集  \n","因此，我们使用5种不同的旋转来生成5种不同的MNIST作为不同的任务\n","\n","## 数据旋转与转换"]},{"cell_type":"code","execution_count":4,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:08.943717Z","iopub.status.busy":"2023-07-19T13:22:08.943360Z","iopub.status.idle":"2023-07-19T13:22:08.955319Z","shell.execute_reply":"2023-07-19T13:22:08.953896Z","shell.execute_reply.started":"2023-07-19T13:22:08.943686Z"},"trusted":true},"outputs":[],"source":["# 旋转 MNIST 数据生成 5 个任务\n","def _rotate_image(image, angle):\n","    if angle is None:\n","        return image\n","    image = transforms.functional.rotate(image, angle=angle)\n","    return image\n","\n","\n","def get_transform(angle=None):\n","    transform = transforms.Compose([\n","        transforms.ToTensor(),\n","       transforms.Lambda(lambda x: _rotate_image(x, angle)),\n","       Pad(28)\n","    ])\n","    return transform\n","\n","\n","class Pad(object):\n","    def __init__(self, size, fill=0, padding_mode='constant'):\n","        self.size = size\n","        self.fill = fill\n","        self.padding_mode = padding_mode\n","\n","    def __call__(self, img):\n","        # 输入图片的长宽是一致的，如果输入图片的size比期望的size小时，对图片的四周进行扩充\n","        img_size = img.size()[1]\n","        assert ((self.size - img_size) % 2 == 0)\n","        padding = (self.size - img_size) // 2\n","        padding = (padding, padding, padding, padding)\n","        return F.pad(img, padding, self.padding_mode, self.fill)\n","\n","    \n","class Data():\n","    def __init__(self, path, train=True, angle=None):\n","        transform = get_transform(angle)\n","        self.dataset = datasets.MNIST(root=os.path.join(path, \"MNIST\"), transform=transform, train=train, download=True)"]},{"cell_type":"markdown","metadata":{},"source":["## 构建Dataloaders数据及训练参数\n","- 一些训练参数\n","  - 设置 5 个不同的旋转\n","  - 5 Train DataLoader\n","  - 5 Test DataLoader "]},{"cell_type":"code","execution_count":5,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:09.957433Z","iopub.status.busy":"2023-07-19T13:22:09.956748Z","iopub.status.idle":"2023-07-19T13:22:14.316591Z","shell.execute_reply":"2023-07-19T13:22:14.315549Z","shell.execute_reply.started":"2023-07-19T13:22:09.957386Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n","Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to data/MNIST/MNIST/raw/train-images-idx3-ubyte.gz\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████| 9912422/9912422 [00:00<00:00, 104073793.49it/s]"]},{"name":"stdout","output_type":"stream","text":["Extracting data/MNIST/MNIST/raw/train-images-idx3-ubyte.gz to data/MNIST/MNIST/raw\n"]},{"name":"stderr","output_type":"stream","text":["\n"]},{"name":"stdout","output_type":"stream","text":["\n","Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n","Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to data/MNIST/MNIST/raw/train-labels-idx1-ubyte.gz\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████| 28881/28881 [00:00<00:00, 40031623.87it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Extracting data/MNIST/MNIST/raw/train-labels-idx1-ubyte.gz to data/MNIST/MNIST/raw\n","\n","Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n","Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to data/MNIST/MNIST/raw/t10k-images-idx3-ubyte.gz\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████| 1648877/1648877 [00:00<00:00, 131303590.15it/s]"]},{"name":"stdout","output_type":"stream","text":["Extracting data/MNIST/MNIST/raw/t10k-images-idx3-ubyte.gz to data/MNIST/MNIST/raw\n","\n","Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n"]},{"name":"stderr","output_type":"stream","text":["\n"]},{"name":"stdout","output_type":"stream","text":["Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to data/MNIST/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████| 4542/4542 [00:00<00:00, 8690934.66it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Extracting data/MNIST/MNIST/raw/t10k-labels-idx1-ubyte.gz to data/MNIST/MNIST/raw\n","\n"]}],"source":["class Args:\n","    task_number = 5\n","    epochs_per_task = 10\n","    lr = 1.0e-4\n","    batch_size = 128\n","    test_size=8192\n","\n","args=Args()\n","\n","device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n","# 给每个task 生成旋转角度.\n","angle_list = [20 * x for x in range(args.task_number)]\n","# 准备5个Task: 不同旋转角度的 MNIST 数据集.\n","train_datasets = [Data('data', angle=angle_list[index]) for index in range(args.task_number)]\n","train_dataloaders = [DataLoader(data.dataset, batch_size=args.batch_size, shuffle=True) for data in train_datasets]\n","\n","test_datasets = [Data('data', train=False, angle=angle_list[index]) for index in range(args.task_number)]\n","test_dataloaders = [DataLoader(data.dataset, batch_size=args.test_size, shuffle=True) for data in test_datasets]"]},{"cell_type":"markdown","metadata":{},"source":["### 可视化"]},{"cell_type":"code","execution_count":6,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:14.319285Z","iopub.status.busy":"2023-07-19T13:22:14.318907Z","iopub.status.idle":"2023-07-19T13:22:17.400497Z","shell.execute_reply":"2023-07-19T13:22:17.399571Z","shell.execute_reply.started":"2023-07-19T13:22:14.319250Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 3000x1000 with 50 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# 分别绘制5个任务中的0-9图像\n","sample = [Data('data', angle=angle_list[index]) for index in range(args.task_number)]\n","\n","plt.figure(figsize=(30, 10))\n","for task in range(5):\n","    target_list = []\n","    cnt = 0\n","    while (len(target_list) < 10):\n","        img, target = sample[task].dataset[cnt]\n","        cnt += 1\n","        if target in target_list:\n","            continue\n","        else:\n","            target_list.append(target)\n","        plt.subplot(5, 10, (task)*10 + target + 1)\n","        curr_img = np.reshape(img, (28, 28))\n","        plt.matshow(curr_img, cmap=plt.get_cmap('gray'), fignum=False)\n","        ax = plt.gca()\n","        ax.axes.xaxis.set_ticks([])\n","        ax.axes.yaxis.set_ticks([])\n","        plt.title(\"task: \" + str(task+1) + \" \" + \"label: \" + str(target), y=1)"]},{"cell_type":"markdown","metadata":{},"source":["# 模型准备 \n","## 模型架构\n","\n","为了公平地比较，采用同一模型进行序列任务连续训练，该模型体系结构由4层全连接层组成。"]},{"cell_type":"code","execution_count":7,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:17.401859Z","iopub.status.busy":"2023-07-19T13:22:17.401503Z","iopub.status.idle":"2023-07-19T13:22:17.428315Z","shell.execute_reply":"2023-07-19T13:22:17.426180Z","shell.execute_reply.started":"2023-07-19T13:22:17.401811Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["Model(\n","  (fc1): Linear(in_features=784, out_features=1024, bias=True)\n","  (fc2): Linear(in_features=1024, out_features=512, bias=True)\n","  (fc3): Linear(in_features=512, out_features=256, bias=True)\n","  (fc4): Linear(in_features=256, out_features=10, bias=True)\n","  (relu): ReLU()\n",")\n"]}],"source":["class Model(nn.Module):\n","    \"\"\"\n","    模型架构\n","    1*28*28 (input) → 1024 → 512 → 256 → 10\n","    \"\"\"\n","    def __init__(self):\n","        super(Model, self).__init__()\n","        self.fc1 = nn.Linear(1*28*28, 1024)\n","        self.fc2 = nn.Linear(1024, 512)\n","        self.fc3 = nn.Linear(512, 256)\n","        self.fc4 = nn.Linear(256, 10)\n","        self.relu = nn.ReLU()\n","\n","    def forward(self, x):\n","        x = x.view(-1, 1*28*28)\n","        x = self.fc1(x)\n","        x = self.relu(x)\n","        x = self.fc2(x)\n","        x = self.relu(x)\n","        x = self.fc3(x)\n","        x = self.relu(x)\n","        x = self.fc4(x)\n","        return x\n","\n","\n","example = Model()\n","print(example)"]},{"cell_type":"markdown","metadata":{},"source":["# 训练与评估\n","\n","## 模型训练\n","以下是我们模型训练的fuction，能同样适用于本次作业中不同的终身学习算法（基于正则化）的训练"]},{"cell_type":"code","execution_count":8,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:17.430740Z","iopub.status.busy":"2023-07-19T13:22:17.430324Z","iopub.status.idle":"2023-07-19T13:22:17.443973Z","shell.execute_reply":"2023-07-19T13:22:17.442642Z","shell.execute_reply.started":"2023-07-19T13:22:17.430707Z"},"trusted":true},"outputs":[],"source":["def train(model, optimizer, dataloader, epochs_per_task, lll_object, lll_lambda, test_dataloaders, evaluate, device, log_step=1):\n","    model.train()\n","    model.zero_grad()\n","    objective = nn.CrossEntropyLoss()\n","    acc_per_epoch = []\n","    loss = 1.0\n","    for epoch in range(epochs_per_task):\n","        tr_bar = tqdm(dataloader, leave=False)\n","        for imgs, labels in  tr_bar: \n","            tr_bar.set_description(f\"[ Train | Epoch {epoch+1:02d}/{epochs_per_task:02d} ]\")\n","            imgs, labels = imgs.to(device), labels.to(device)\n","            outputs = model(imgs)\n","            loss = objective(outputs, labels)\n","            total_loss = loss\n","            # ----------  正则化 ----------\n","            lll_loss = lll_object.penalty(model)\n","            total_loss += lll_lambda * lll_loss \n","            # model update\n","            lll_object.update(model)\n","            # ----------------------------\n","            optimizer.zero_grad()\n","            total_loss.backward()\n","            optimizer.step()\n","\n","            loss = total_loss.item()\n","            tr_bar.set_postfix({\"Loss\": f\"{loss:.7f}\"})\n","\n","        acc_average  = []\n","        for test_dataloader in test_dataloaders: \n","            acc_test = evaluate(model, test_dataloader, device)\n","            acc_average.append(acc_test)\n","        average = np.mean(np.array(acc_average))\n","        acc_per_epoch.append(average*100.0)\n","        print(f\"[ Val | Epoch {epoch+1:02d}/{epochs_per_task:02d} ] acc={average*100:.3f} %\")\n","    return model, optimizer, acc_per_epoch"]},{"cell_type":"markdown","metadata":{},"source":["## 模型评估\n","以下是我们模型评估的fuction，能同样适用于本次作业中不同的终身学习算法（基于正则化）的评估\n"]},{"cell_type":"code","execution_count":9,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:17.446886Z","iopub.status.busy":"2023-07-19T13:22:17.446223Z","iopub.status.idle":"2023-07-19T13:22:17.453960Z","shell.execute_reply":"2023-07-19T13:22:17.453259Z","shell.execute_reply.started":"2023-07-19T13:22:17.446852Z"},"trusted":true},"outputs":[],"source":["def evaluate(model, test_dataloader, device):\n","    model.eval()\n","    correct_cnt = 0\n","    total = 0\n","    for imgs, labels in test_dataloader:\n","        imgs, labels = imgs.to(device), labels.to(device)\n","        outputs = model(imgs)\n","        _, pred_label = torch.max(outputs.data, 1)\n","\n","        correct_cnt += (pred_label == labels.data).sum().item()\n","        total += torch.ones_like(labels.data).sum().item()\n","    return correct_cnt / total"]},{"cell_type":"markdown","metadata":{},"source":["# &#x2728; 终生学习——基于正则化的`prior-focused`方法\n","- Baseline\n","- EWC\n","- SI\n","- MAS\n","- RWalk\n","- SCP"]},{"cell_type":"code","execution_count":10,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:17.455765Z","iopub.status.busy":"2023-07-19T13:22:17.455196Z","iopub.status.idle":"2023-07-19T13:22:17.465654Z","shell.execute_reply":"2023-07-19T13:22:17.464881Z","shell.execute_reply.started":"2023-07-19T13:22:17.455733Z"},"trusted":true},"outputs":[],"source":["class baseline(object):\n","    \"\"\"\n","    基准`baseline`方法 : 不做正则化 [ 初始化权重矩阵全为0 ]\n","    \"\"\"\n","    def __init__(self, model, dataloader, device):\n","        self.model = model\n","        self.dataloader = dataloader\n","        self.device = device\n","        # 提取模型中的所有参数\n","        self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad} \n","        # 保存当前参数\n","        self.p_old = {} \n","        # 生成权重矩阵-全都为0\n","        self._precision_matrices = self._calculate_importance()  \n","        for n, p in self.params.items():\n","            # 将原始参数保存在 p_old 中- 保存为不可导\n","            self.p_old[n] = p.clone().detach() \n","\n","    def _calculate_importance(self):\n","        precision_matrices = {} \n","        # 初始化权重（fill zero）\n","        for n, p in self.params.items(): \n","            precision_matrices[n] = p.clone().detach().fill_(0)\n","\n","        return precision_matrices\n","\n","    def penalty(self, model: nn.Module):\n","        loss = 0\n","        for n, p in model.named_parameters():\n","            _loss = self._precision_matrices[n] * (p - self.p_old[n]) ** 2\n","            loss += _loss.sum()\n","        return loss\n","\n","    def update(self, model):\n","        # do nothing\n","        return"]},{"cell_type":"code","execution_count":12,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:22:18.713526Z","iopub.status.busy":"2023-07-19T13:22:18.713151Z","iopub.status.idle":"2023-07-19T13:55:14.325717Z","shell.execute_reply":"2023-07-19T13:55:14.324754Z","shell.execute_reply.started":"2023-07-19T13:22:18.713494Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN BASELINE\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"e21cc561717a4219998ff95946ff0053","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.550 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.600 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.760 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.180 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=97.160 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=97.400 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.490 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.670 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.460 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.980 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=95.620 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=95.795 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.510 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=95.610 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=95.425 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=95.600 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=95.155 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=95.320 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=95.145 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=95.545 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=91.120 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=89.743 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=89.443 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=89.493 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=87.483 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=88.507 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=88.177 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=87.470 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=87.790 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=86.427 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=82.305 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=79.635 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=79.445 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=79.095 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=79.532 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=78.125 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=78.527 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=79.185 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=77.377 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=77.732 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=75.250 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=73.334 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=72.194 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=72.112 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=71.668 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=70.198 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=71.178 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=70.718 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=70.052 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=69.880 %\n","[92.55, 94.6, 95.76, 96.17999999999999, 97.16, 97.39999999999999, 97.49, 97.67, 97.46000000000001, 97.98, 95.61999999999999, 95.795, 95.51, 95.61, 95.42500000000001, 95.6, 95.155, 95.32000000000001, 95.145, 95.54499999999999, 91.12, 89.74333333333333, 89.44333333333333, 89.49333333333334, 87.48333333333332, 88.50666666666667, 88.17666666666666, 87.47, 87.79, 86.42666666666666, 82.30499999999999, 79.63499999999999, 79.445, 79.095, 79.5325, 78.125, 78.52749999999999, 79.18499999999999, 77.3775, 77.73249999999999, 75.25, 73.334, 72.194, 72.112, 71.66799999999999, 70.19800000000001, 71.178, 70.718, 70.05199999999999, 69.88000000000001]\n","==================================================================================================\n"]}],"source":["# Baseline\n","print(\"RUN BASELINE\")\n","model = Model()\n","model = model.to(device)\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","lll_object=baseline(model=model, dataloader=None, device=device)\n","lll_lambda=0.0\n","baseline_acc=[]\n","task_bar = tqdm(range(len(train_dataloaders)))\n","\n","# 不断地对每项任务进行迭代训练\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    # 训练每个任务\n","    model, _, acc_list = train(\n","        model, optimizer, train_dataloaders[train_indexes], \n","        args.epochs_per_task, \n","        lll_object, lll_lambda, \n","        evaluate=evaluate,\n","        device=device, \n","        # 评估 所有训练过的task对应的test数据\n","        test_dataloaders=test_dataloaders[:train_indexes+1])\n","\n","    # 获取模型权重（对于baseline 实际无任何变化） \n","    lll_object=baseline(model=model, dataloader=train_dataloaders[train_indexes],device=device)\n","    # 使用新的优化器\n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","    # 收集每个epoch的平均精度\n","    baseline_acc.extend(acc_list)\n","\n","\n","print(baseline_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["## &#x2728;  EWC\n","> 输入 新task的训练数据和`label`\n","\n","弹性权重合并(`Elastic Weight Consolidation`)\n","\n","`ewc` 类中实现了`EWC`算法去计算正则项。这个核心概念可以看李宏毅老师的课程。这里我们将重点讨论EWC的算法。  \n","在这项作业中，我们想让我们的模型依次学习10项任务。这里我们展示了一个简单的例子，让模型依次学习2个任务（任务a和任务B）。\n","\n","在 EWC 算法中, 损失函数定义如下:\n"," $$\\mathcal{L}_B = \\mathcal{L}(\\theta) + \\sum_{i} \\frac{\\lambda}{2} F_i (\\theta_{i} - \\theta_{A,i}^{*})^2  $$\n","  \n","假设我们有一个具有两个以上参数的神经网络。 $F_i$对应于李宏毅教授讲座中的$i^{th}$守卫. 请不要修改此参数，因为它对任务A很重要。\n","\n","$F$定义如下:  **即梯度的平方**\n","$$ F = [ \\nabla \\log(p(y_n | x_n, \\theta_{A}^{*})) \\nabla \\log(p(y_n | x_n, \\theta_{A}^{*}))^T ] $$ \n","\n","我们只取矩阵的对角线值来近似每个参数的$F_i$.\n","\n","详细信息和推导在[Continual Learning in Neural\n","Networks](https://arxiv.org/pdf/1910.02718.pdf) 中 2.4.1 and 2.4 \n","\n","参考论文: [Elastic Weight Consolidation](https://arxiv.org/pdf/1612.00796.pdf)"]},{"cell_type":"code","execution_count":13,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:55:14.328676Z","iopub.status.busy":"2023-07-19T13:55:14.327992Z","iopub.status.idle":"2023-07-19T13:55:14.343854Z","shell.execute_reply":"2023-07-19T13:55:14.342662Z","shell.execute_reply.started":"2023-07-19T13:55:14.328639Z"},"trusted":true},"outputs":[],"source":["class ewc(object):\n","    \"\"\"\n","    @article{kirkpatrick2017overcoming,\n","        title={Overcoming catastrophic forgetting in neural networks},\n","        author={Kirkpatrick, James and Pascanu, Razvan and Rabinowitz, Neil and Veness, Joel and Desjardins, Guillaume and Rusu, Andrei A and Milan, Kieran and Quan, John and Ramalho, Tiago and Grabska-Barwinska, Agnieszka and others},\n","        journal={Proceedings of the national academy of sciences},\n","        year={2017},\n","        url={https://arxiv.org/abs/1612.00796}\n","    }\n","    \"\"\"\n","    def __init__(self, model, dataloader, device, prev_guards=[None]):\n","        self.model = model\n","        self.dataloader = dataloader\n","        self.device = device\n","        # 提取模型中的所有参数\n","        self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad} \n","        self.p_old = {}\n","        # 保存之前的 guards\n","        self.previous_guard_list = prev_guards\n","        # 生成EWC的权重Fisher (F)矩阵， 即 F 函数\n","        self._precision_matrices = self._calculate_importance()\n","        for n, p in self.params.items():\n","            # 保留原始数据 - 保存为不可导\n","            self.p_old[n] = p.clone().detach()\n","        \n","    def _calculate_importance(self):\n","        out = {}\n","        # 初始化 Fisher (F) 矩阵（全部填充0）并加上之前的 guards\n","        for n, p in self.params.items():\n","            out[n] = p.clone().detach().fill_(0)\n","            for prev_guard in self.previous_guard_list:\n","                if prev_guard:\n","                    out[n] += prev_guard[n]\n","\n","        self.model.eval()\n","        if self.dataloader is not None:\n","            number_data = len(self.dataloader)\n","            for x, y in self.dataloader:\n","                self.model.zero_grad()\n","                x, y = x.to(self.device), y.to(self.device)\n","                pred = self.model(x)\n","                # 为EWC 生成 Fisher(F) 矩阵\n","                loss = F.nll_loss(F.log_softmax(pred, dim=1), y)\n","                loss.backward()\n","            \n","                for n, p in self.model.named_parameters():\n","                    # 获取每个参数的样本平均 梯度平方\n","                    out[n].data += p.grad.data ** 2 / number_data\n","                    \n","        out = {n: p for n, p in out.items()}\n","        return out\n","\n","    def penalty(self, model: nn.Module):\n","        loss = 0\n","        for n, p in model.named_parameters():\n","            # 最终的正则项 =   ewc权重 * 权重变化平方((p - self.p_old[n]) ** 2) \n","            _loss = self._precision_matrices[n] * (p - self.p_old[n]) ** 2\n","            loss += _loss.sum()\n","        return loss\n","  \n","    def update(self, model):\n","        return "]},{"cell_type":"code","execution_count":14,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T13:55:14.345594Z","iopub.status.busy":"2023-07-19T13:55:14.345197Z","iopub.status.idle":"2023-07-19T14:29:35.772179Z","shell.execute_reply":"2023-07-19T14:29:35.771201Z","shell.execute_reply.started":"2023-07-19T13:55:14.345560Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN EWC\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"63fa77d39e5a4edbae11a25817a91d33","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.510 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.620 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.620 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.180 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.600 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=97.200 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.280 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.460 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.710 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.770 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=95.560 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=96.025 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.735 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=95.820 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=95.700 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=95.815 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=95.145 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=95.325 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=95.530 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=95.370 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=91.413 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=89.637 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=89.070 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=88.257 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=88.490 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=87.453 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=87.257 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=87.943 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=87.053 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=87.193 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=82.652 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=80.933 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=80.295 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=80.890 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=80.627 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=79.047 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=80.892 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=79.985 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=80.362 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=80.453 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=75.130 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=74.170 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=73.164 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=72.166 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=71.448 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=72.100 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=73.048 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=72.676 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=71.998 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=72.202 %\n","[92.51, 94.62, 95.62, 96.17999999999999, 96.6, 97.2, 97.28, 97.46000000000001, 97.71, 97.77, 95.56, 96.025, 95.73499999999999, 95.82, 95.7, 95.81500000000001, 95.145, 95.32499999999999, 95.53, 95.37, 91.41333333333334, 89.63666666666667, 89.07, 88.25666666666666, 88.49000000000001, 87.45333333333333, 87.25666666666667, 87.94333333333334, 87.05333333333334, 87.19333333333333, 82.65249999999999, 80.9325, 80.295, 80.89, 80.62749999999998, 79.0475, 80.8925, 79.985, 80.3625, 80.4525, 75.13, 74.17, 73.164, 72.166, 71.44800000000001, 72.10000000000001, 73.048, 72.676, 71.99799999999999, 72.20199999999998]\n","==================================================================================================\n"]}],"source":["# EWC\n","print(\"RUN EWC\")\n","model = Model()\n","model = model.to(device)\n","# 初始化优化器\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","lll_object=ewc(model=model, dataloader=None, device=device)\n","# 设置正则项系数\n","lll_lambda=100\n","ewc_acc= []\n","task_bar = tqdm(range(len(train_dataloaders)))\n","prev_guards = []\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    model, _, acc_list = train(\n","        model, optimizer, train_dataloaders[train_indexes], \n","        args.epochs_per_task, lll_object, lll_lambda, \n","        evaluate=evaluate,device=device, \n","        # 评估 所有训练过的task对应的test数据\n","        test_dataloaders=test_dataloaders[:train_indexes+1])\n","\n","    # 获取模型权重 并 计算每个权重的ewc-guidance权重\n","    prev_guards.append(lll_object._precision_matrices)\n","    lll_object=ewc(model=model, dataloader=train_dataloaders[train_indexes], device=device, prev_guards=prev_guards)\n","\n","    # 使用新的优化器\n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","    # 收集每个epoch的平均精度\n","    ewc_acc.extend(acc_list)\n","\n","\n","print(ewc_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["## &#x2728; MAS\n","> 输入 新task的训练数据\n","\n","<font color=darkred><b>TODO: 基于论文公式编写 Omega(Ω) 矩阵的生成</font></b>\n","\n","\n","记忆感知突触(`Memory Aware Synapses`)  \n","`mas` 类中实现了`MAS`算法去计算正则项。\n","\n","`MAS` 的核心和`EWC`相似, 唯一的区别是重要权重（`important weight`）的计算。  \n","以下提到了详细信息。\n","\n","MAS:\n","\n","在`MAS`中损失函数如下, 模型在学习任务B之前学习任务A。\n","\n","$$\\mathcal{L}_B = \\mathcal{L}(\\theta) + \\sum_{i} \\frac{\\lambda}{2} \\Omega_i (\\theta_{i} - \\theta_{A,i}^{*})^2$$\n","\n","相对`EWC`来说, 在损失函数中 $F_i$ 被 $\\Omega_i$ 替代，$\\Omega_i$ 计算方法如下\n","\n","$$\\Omega_i = || \\frac{\\partial \\ell_2^2(M(x_k; \\theta))}{\\partial \\theta_i} || $$ \n","\n","$x_k$ 是之前任务中的样本数据。所以 $\\Omega$是所学习的网络输出的平方L2范数的梯度。  \n","论文中提出的方法是通过从模型的每一层获取平方L2范数输出的局部版本。\n","在这里，我们只需要你通过模型的最后一层获取输出来实现全局版本。\n","\n","参考论文: \n","[Memory Aware Synapses](https://arxiv.org/pdf/1711.09601.pdf)\n","\n"]},{"cell_type":"code","execution_count":15,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T14:29:35.775947Z","iopub.status.busy":"2023-07-19T14:29:35.775240Z","iopub.status.idle":"2023-07-19T14:29:35.789946Z","shell.execute_reply":"2023-07-19T14:29:35.788975Z","shell.execute_reply.started":"2023-07-19T14:29:35.775908Z"},"trusted":true},"outputs":[],"source":["class mas(object):\n","    \"\"\"\n","    @article{aljundi2017memory,\n","        title={Memory Aware Synapses: Learning what (not) to forget},\n","        author={Aljundi, Rahaf and Babiloni, Francesca and Elhoseiny, Mohamed and Rohrbach, Marcus and Tuytelaars, Tinne},\n","        booktitle={ECCV},\n","        year={2018},\n","        url={https://eccv2018.org/openaccess/content_ECCV_2018/papers/Rahaf_Aljundi_Memory_Aware_Synapses_ECCV_2018_paper.pdf}\n","    }\n","    \"\"\"\n","    def __init__(self, model, dataloader, device, prev_guards=[None]):\n","        self.model = model \n","        self.dataloader = dataloader\n","        # 提取模型全部参数\n","        self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad} \n","        # 参数初始化\n","        self.p_old = {} \n","        self.device = device\n","        # 保存之前的 guards\n","        self.previous_guards_list = prev_guards\n","        # 生成 Omega(Ω) 矩阵\n","        self._precision_matrices = self._calculate_importance() \n","        for n, p in self.params.items():\n","            # 保留原始数据 - 保存为不可导\n","            self.p_old[n] = p.clone().detach()\n","\n","    def _calculate_importance(self):\n","        out = {}\n","        # 初始化 Omega(Ω) 矩阵（全部填充0）并加上之前的 guards\n","        for n, p in self.params.items():\n","            out[n] = p.clone().detach().fill_(0)\n","            for prev_guard in self.previous_guards_list:\n","                if prev_guard:\n","                    out[n] += prev_guard[n]\n","\n","        self.model.eval()\n","        if self.dataloader is not None:\n","            number_data = len(self.dataloader)\n","            for x, y in self.dataloader:\n","                self.model.zero_grad()\n","                x, y = x.to(self.device), y.to(self.device)\n","                pred = self.model(x)\n","                ################################################################\n","                #####  TODO: 生成 Omega(Ω) 矩阵.  #####   \n","                ################################################################\n","                # 网络输出 L2范数平方的梯度\n","                loss = torch.mean(torch.sum(pred ** 2, axis=1))\n","                loss.backward()\n","                for n, p in self.model.named_parameters():\n","                    out[n].data += torch.sqrt(p.grad.data ** 2) / number_data\n","                ################################################################      \n","\n","        out = {n: p for n, p in out.items()}\n","        return out\n","\n","    def penalty(self, model: nn.Module):\n","        loss = 0\n","        for n, p in model.named_parameters():\n","            # 最终的正则项 =   Omega(Ω)权重 * 权重变化平方((p - self.p_old[n]) ** 2) \n","            _loss = self._precision_matrices[n] * (p - self.p_old[n]) ** 2\n","            loss += _loss.sum()\n","        return loss\n","  \n","    def update(self, model):\n","        return \n"]},{"cell_type":"code","execution_count":16,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T14:29:35.791523Z","iopub.status.busy":"2023-07-19T14:29:35.790932Z","iopub.status.idle":"2023-07-19T15:02:54.753257Z","shell.execute_reply":"2023-07-19T15:02:54.752280Z","shell.execute_reply.started":"2023-07-19T14:29:35.791490Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN MAS\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"8d5ea6e6cc6a461f97b2babee61b02a7","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.890 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.640 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.780 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.330 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.750 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=97.270 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.410 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.580 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.740 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.900 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=96.145 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=96.375 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=96.055 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.045 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.290 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=96.270 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=95.995 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=96.265 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=96.120 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=95.885 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.277 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=92.840 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=93.053 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=91.137 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=92.387 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=92.690 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=92.793 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=92.727 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=92.367 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=92.590 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=87.858 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=87.645 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=87.885 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=87.783 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=87.467 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=88.270 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=88.272 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=87.735 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=87.475 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=88.650 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=84.974 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=83.210 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=83.922 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=84.592 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=83.498 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=83.428 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=83.942 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=83.738 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=83.644 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=84.218 %\n","[92.89, 94.64, 95.78, 96.33, 96.75, 97.27, 97.41, 97.58, 97.74000000000001, 97.89999999999999, 96.145, 96.375, 96.055, 96.045, 96.29, 96.27, 95.99499999999999, 96.265, 96.12, 95.88499999999999, 92.27666666666666, 92.83999999999999, 93.05333333333334, 91.13666666666667, 92.38666666666666, 92.69, 92.79333333333334, 92.72666666666667, 92.36666666666666, 92.59, 87.85750000000002, 87.645, 87.885, 87.78250000000001, 87.46749999999999, 88.27000000000001, 88.2725, 87.735, 87.47500000000001, 88.65, 84.974, 83.21, 83.92200000000001, 84.59200000000001, 83.498, 83.428, 83.942, 83.73799999999999, 83.64399999999999, 84.21800000000002]\n","==================================================================================================\n"]}],"source":["# MAS\n","print(\"RUN MAS\")\n","model = Model()\n","model = model.to(device)\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","lll_object=mas(model=model, dataloader=None, device=device)\n","lll_lambda=0.1\n","mas_acc= []\n","task_bar = tqdm(range(len(train_dataloaders)))\n","prev_guards = []\n","\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    model, _, acc_list = train(model, optimizer, train_dataloaders[train_indexes], args.epochs_per_task, lll_object, lll_lambda, \n","                               evaluate=evaluate,device=device, \n","                               # 评估 所有训练过的task对应的test数据\n","                               test_dataloaders=test_dataloaders[:train_indexes+1])\n","\n","    # 获取模型权重 并 计算每个权重的 mas-guidance权重\n","    prev_guards.append(lll_object._precision_matrices)\n","    lll_object=mas(model=model, dataloader=train_dataloaders[train_indexes], device=device, prev_guards=prev_guards)\n","\n","    # 使用新的优化器\n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","    # 收集每个epoch的平均精度\n","    mas_acc.extend(acc_list)\n","\n","\n","print(mas_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["## &#x2728; SI\n","\n","`si`类中实现了 突触智能 (`Synaptic Intelligence`)算法去计算正则项\n","\n","在`SI`中损失函数如下, 模型在学习任务B之前学习任务A。\n","\n","$$\\mathcal{L}_B = \\mathcal{L}(\\theta) +  c \\sum_{i}\\Omega_i (\\theta_{i} - \\theta_{A,i}^{*})^2$$\n","\n","$\\Omega_i $ 计算如下：\n","$$\\Omega_i = \\frac{\\mathcal{w}_i}{(\\Delta _i)^2 + \\epsilon} $$ \n","- $\\int _C \\mathcal{g}(\\theta (t))d\\theta= \\int_{t_0}^{t_1}\\mathcal{g}(\\theta (t)) \\dot \\theta^{'}(t)dt=-\\sum_k\\mathcal{w}_k$\n","    - 简单理解就是 `-W`权重等于模型当前梯度$\\mathcal{g(\\theta (t))}$ 乘以 参数前后变化$\\theta^{'}(t)$ \n","    - code: `self.W[n].add_(-p.grad * (p.detach() - self.p_old[n]))`\n","\n","参考论文：\n","[Continual Learning Through Synaptic Intelligence](https://arxiv.org/pdf/1703.04200.pdf)"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T15:02:54.755485Z","iopub.status.busy":"2023-07-19T15:02:54.754568Z","iopub.status.idle":"2023-07-19T15:02:54.774049Z","shell.execute_reply":"2023-07-19T15:02:54.773053Z","shell.execute_reply.started":"2023-07-19T15:02:54.755447Z"},"trusted":true},"outputs":[],"source":["# SI\n","class si(object):\n","    \"\"\"\n","    @article{kirkpatrick2017overcoming,\n","        title={Overcoming catastrophic forgetting in neural networks},\n","        author={Kirkpatrick, James and Pascanu, Razvan and Rabinowitz, Neil and Veness, Joel and Desjardins, Guillaume and Rusu, Andrei A and Milan, Kieran and Quan, John and Ramalho, Tiago and Grabska-Barwinska, Agnieszka and others},\n","        journal={Proceedings of the national academy of sciences},\n","        year={2017},\n","        url={https://arxiv.org/abs/1612.00796}\n","    }\n","    \"\"\"\n","    def __init__(self, model, dataloader, epsilon, device):\n","        self.model = model\n","        self.dataloader = dataloader\n","        self.device = device\n","        self.epsilon = epsilon\n","        # 提取模型全部参数\n","        self.params = {n.replace('.', '__'): p for n, p in self.model.named_parameters() if p.requires_grad}\n","        # 计算权重\n","        self._n_p_prev, self._n_omega = self._calculate_importance() \n","        self.W, self.p_old = self._init_()\n","    \n","    def _init_(self):\n","        W = {}\n","        p_old = {}\n","        for n, p in self.params.items():\n","            W[n] = p.data.clone().zero_()\n","            p_old[n] = p.data.clone()\n","        return W, p_old\n","\n","    def _calculate_importance(self):\n","        n_p_prev = {}\n","        n_omega = {}\n","        \n","        for n, p in self.params.items():\n","            if self.dataloader is not None: # dataloader的作用是提示是否已经训练过\n","                # 查找/计算参数二次惩罚（quadratic penalty）的新值\n","                p_prev = getattr(self.model, f'{n}_SI_prev_task')\n","                W = getattr(self.model, f'{n}_W')\n","                p_cur = p.detach().clone()\n","                delta = p_cur - p_prev\n","                omega_add = W / (delta ** 2 + self.epsilon)\n","                try:\n","                    omega = getattr(self.model, f'{n}_SI_omega')\n","                except AttributeError:\n","                    omega = p.detach().clone().zero_()\n","                \n","                omega_new = omega + omega_add\n","                n_omega[n] = omega_new\n","                n_p_prev[n] = p_cur\n","                \n","                # 保存新参数到模型中\n","                self.model.register_buffer(f'{n}_SI_prev_task', p_cur)\n","                self.model.register_buffer(f'{n}_SI_omega', omega_new)\n","                continue\n","\n","            n_p_prev[n] = p.detach().clone()\n","            n_omega[n] = p.detach().clone().zero_()\n","            self.model.register_buffer(f'{n}_SI_prev_task', p.detach().clone())\n","        return n_p_prev, n_omega\n","\n","    def penalty(self, model):\n","        loss = 0.0 \n","        for n, p in model.named_parameters():\n","            n = n.replace('.', '__')\n","            if p.requires_grad:\n","                _loss = self._n_omega[n] * (p - self._n_p_prev[n]) ** 2\n","                loss += _loss.sum()\n","        return loss\n","    \n","    def update(self, model):\n","        for n, p in model.named_parameters():\n","            n = n.replace('.', '__')\n","            if p.requires_grad:\n","                if p.grad is not None:\n","                    #  - \\sum_k grad *  \\theta (t)'\n","                    self.W[n].add_(-p.grad * (p.detach() - self.p_old[n]))\n","                    self.model.register_buffer(f'{n}_W', self.W[n])\n","                self.p_old[n] = p.detach().clone()\n","        return \n"]},{"cell_type":"code","execution_count":18,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T15:02:54.775948Z","iopub.status.busy":"2023-07-19T15:02:54.775468Z","iopub.status.idle":"2023-07-19T15:35:08.397326Z","shell.execute_reply":"2023-07-19T15:35:08.389426Z","shell.execute_reply.started":"2023-07-19T15:02:54.775916Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN SI\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"f6b24be583314146a4678c42a8ac8441","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.400 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.620 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.210 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.240 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.770 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=97.200 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.450 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.580 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.740 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.720 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=95.815 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=95.385 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.280 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=95.665 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=95.855 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=94.770 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=96.045 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=95.930 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=95.500 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=95.940 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=90.363 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=90.310 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=89.290 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=88.600 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=89.610 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=89.463 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=89.873 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=89.223 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=88.670 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=89.257 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=84.295 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=81.947 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=81.340 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=81.993 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=81.640 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=80.972 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=81.108 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=81.753 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=82.125 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=82.150 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=76.094 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=76.640 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=75.398 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=74.512 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=74.964 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=74.860 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=75.704 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=75.162 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=74.766 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=72.422 %\n","[92.4, 94.62, 95.21, 96.24000000000001, 96.77, 97.2, 97.45, 97.58, 97.74000000000001, 97.72, 95.81500000000001, 95.385, 95.28000000000002, 95.665, 95.855, 94.77, 96.045, 95.93, 95.5, 95.94, 90.36333333333334, 90.30999999999999, 89.29, 88.6, 89.61, 89.46333333333335, 89.87333333333333, 89.22333333333333, 88.66999999999999, 89.25666666666667, 84.29500000000002, 81.94749999999999, 81.34, 81.9925, 81.64, 80.9725, 81.1075, 81.75250000000001, 82.125, 82.15, 76.094, 76.64, 75.39800000000001, 74.512, 74.964, 74.86, 75.70400000000001, 75.16199999999999, 74.766, 72.422]\n","==================================================================================================\n"]}],"source":["# SI\n","print(\"RUN SI\")\n","model = Model()\n","model = model.to(device)\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","lll_object=si(model=model, dataloader=None, epsilon=0.1, device=device)\n","lll_lambda=1\n","si_acc = []\n","task_bar = tqdm(range(len(train_dataloaders)))\n","\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    model, _, acc_list = train(model, optimizer, train_dataloaders[train_indexes], args.epochs_per_task, lll_object, lll_lambda, \n","                               evaluate=evaluate,device=device, \n","                               test_dataloaders=test_dataloaders[:train_indexes+1])\n","\n","    # 获取模型权重 并 计算每个权重的 SI-guidance权重\n","    lll_object=si(model=model, dataloader=train_dataloaders[train_indexes], epsilon=0.1, device=device)\n","\n","    # 使用新的优化器\n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","    # 收集每个epoch的平均精度\n","    si_acc.extend(acc_list)\n","    \n","\n","print(si_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["## &#x2728; RWalk\n","增量学习的Remanian Walk\n","\n","`rwalk`类中实现了`Remanian Walk`算法去计算正则项\n","\n","<font color=darkred><b>结合了ewc和SI</b></font>\n","\n","参考论文：\n","[Riemannian Walk for Incremental Learning](https://arxiv.org/abs/1801.10112)"]},{"cell_type":"code","execution_count":19,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T15:35:08.399182Z","iopub.status.busy":"2023-07-19T15:35:08.398761Z","iopub.status.idle":"2023-07-19T15:35:08.449783Z","shell.execute_reply":"2023-07-19T15:35:08.448633Z","shell.execute_reply.started":"2023-07-19T15:35:08.399142Z"},"trusted":true},"outputs":[],"source":["\n","\n","class rwalk:\n","    def __init__(self, model, dataloader, epsilon, device, prev_guards=[None]):\n","        self.model = model\n","        self.dataloader = dataloader\n","        self.device = device\n","        self.epsilon = epsilon\n","        self.update_ewc_parameter = 0.4\n","        # 提取模型全部参数\n","        self.params = {n.replace('.', '__'): p for n, p in self.model.named_parameters() if p.requires_grad}\n","        # 初始化 guidance martix\n","        self._means = {} \n","        self.previous_guards_list = prev_guards\n","        \n","        # 生成 ewc-Fisher (F) 信息矩阵\n","        self._precision_matrices = self._calculate_importance_ewc()\n","        \n","        self._n_p_prev, self._n_omega = self._calculate_importance() \n","        self.W, self.p_old = self._init_()\n","\n","    def _init_(self):\n","        W = {}\n","        p_old = {}\n","        for n, p in self.params.items():\n","            W[n] = p.data.clone().zero_()\n","            p_old[n] = p.data.clone()\n","        return W, p_old\n","    \n","    def _calculate_importance_ewc(self):\n","        out = {}\n","        # 初始化 Fisher (F) 矩阵（全部填充0）并加上之前的 guards\n","        for n, p in self.params.items():\n","            out[n] = p.clone().detach().fill_(0)\n","            for prev_guard in self.previous_guards_list:\n","                if prev_guard:\n","                    out[n] += prev_guard[n]\n","\n","        self.model.eval()\n","\n","        if self.dataloader is not None:\n","            number_data = len(self.dataloader)                \n","            for x, y in self.dataloader:\n","                self.model.zero_grad()\n","                x, y = x.to(self.device), y.to(self.device)\n","                pred = self.model(x)\n","                # 为EWC 生成 Fisher(F) 矩阵\n","                loss = F.nll_loss(F.log_softmax(pred, dim=1), y)\n","                loss.backward()                                                                                                     \n","                                                                                                                                                    \n","                for n, p in self.model.named_parameters():                                                 \n","                    n = n.replace('.', '__')\n","                    # 和 ewc 不一样的是进行了软更新\n","                    out[n].data = (1 - self.update_ewc_parameter) * out[n].data + self.update_ewc_parameter * p.grad.data ** 2 / number_data    \n","                                                                       \n","            out = {n: p for n, p in out.items()}\n","        return out\n","\n","    def _calculate_importance(self):\n","        n_p_prev = {}\n","        n_omega = {}\n","        for n, p in self.params.items():\n","            if self.dataloader is not None:\n","                p_prev = getattr(self.model, f'{n}_SI_prev_task')\n","                W = getattr(self.model, f'{n}_W')\n","                p_cur = p.detach().clone()\n","                delta = p_cur - p_prev\n","                # 这部分相比SI delta**2 增加了  0. 5* ewc的权重\n","                omega_add = W / (1.0 / 2.0 * self._precision_matrices[n] * delta ** 2 + self.epsilon)\n","                try:\n","                        omega = getattr(self.model, '{}_SI_omega'.format(n))\n","                except AttributeError:\n","                        omega = p.detach().clone().zero_()\n","                \n","                # 这部分和SI不一样 进行软更新\n","                omega_new = 0.5 * omega + 0.5 * omega_add\n","                n_omega[n] = omega_new\n","                n_p_prev[n] = p_cur\n","                # 保存新参数到模型中\n","                self.model.register_buffer(f'{n}_SI_prev_task', p_cur)\n","                self.model.register_buffer(f'{n}_SI_omega', omega_new)\n","                continue\n","\n","            n_p_prev[n] = p.detach().clone()\n","            n_omega[n] = p.detach().clone().zero_()\n","            self.model.register_buffer(f'{n}_SI_prev_task', p.detach().clone())\n","        return n_p_prev, n_omega\n","\n","    def penalty(self, model: nn.Module):\n","        loss = 0.0\n","        for n, p in model.named_parameters():\n","            n = n.replace('.', '__')\n","            if p.requires_grad:\n","                prev_values = self._n_p_prev[n]\n","                omega = self._n_omega[n]\n","                # 正则项 最终的权重 = ewc-权重 + SI-权重\n","                _loss = (omega + self._precision_matrices[n]) * (p - prev_values) ** 2\n","                loss += _loss.sum()\n","        return loss\n","  \n","    def update(self, model):\n","        for n, p in model.named_parameters():\n","            n = n.replace('.', '__')\n","            if p.requires_grad:\n","                if p.grad is not None:\n","                    #  - \\sum_k grad *  \\theta (t)'\n","                    self.W[n].add_(-p.grad * (p.detach() - self.p_old[n]))\n","                    self.model.register_buffer(f'{n}_W', self.W[n])\n","                self.p_old[n] = p.detach().clone()\n","        return \n","\n"]},{"cell_type":"code","execution_count":20,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T15:35:08.454012Z","iopub.status.busy":"2023-07-19T15:35:08.453528Z","iopub.status.idle":"2023-07-19T16:09:27.120871Z","shell.execute_reply":"2023-07-19T16:09:27.119895Z","shell.execute_reply.started":"2023-07-19T15:35:08.453981Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN Rwalk\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"a5a47853dd4143809fc0c8bcfa79e8c9","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=91.970 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.440 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.790 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.450 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.750 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=96.950 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.420 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.320 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.550 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.310 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=96.145 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=96.195 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=96.525 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.540 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.305 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=96.535 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=96.150 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=96.235 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=96.500 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=96.225 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.457 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=92.797 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=92.787 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=92.833 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=92.120 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=92.410 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=92.853 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=92.360 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=92.933 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=92.003 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=86.200 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=85.565 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=85.388 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=85.280 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=85.822 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=85.760 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=85.888 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=86.112 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=85.062 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=85.407 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=79.426 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=79.128 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=80.022 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=79.692 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=78.874 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=78.288 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=79.740 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=78.682 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=76.202 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=77.480 %\n","[91.97, 94.44, 95.78999999999999, 96.45, 96.75, 96.95, 97.42, 97.32, 97.55, 97.31, 96.145, 96.195, 96.52499999999999, 96.54, 96.30499999999999, 96.535, 96.15, 96.235, 96.50000000000001, 96.22500000000001, 92.45666666666666, 92.79666666666667, 92.78666666666666, 92.83333333333333, 92.12000000000002, 92.41, 92.85333333333334, 92.36, 92.93333333333332, 92.00333333333333, 86.2, 85.565, 85.3875, 85.28, 85.82249999999999, 85.76, 85.8875, 86.1125, 85.0625, 85.4075, 79.426, 79.128, 80.022, 79.69200000000001, 78.874, 78.288, 79.74, 78.682, 76.202, 77.47999999999999]\n","==================================================================================================\n"]}],"source":["# RWalk\n","print(\"RUN Rwalk\")\n","model = Model()\n","model = model.to(device)\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","lll_object=rwalk(model=model, dataloader=None, epsilon=0.1, device=device)\n","lll_lambda=100\n","rwalk_acc = []\n","task_bar = tqdm(range(len(train_dataloaders)))\n","prev_guards = []\n","\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    model, _, acc_list = train(model, optimizer, train_dataloaders[train_indexes], args.epochs_per_task, lll_object, lll_lambda, \n","                               evaluate=evaluate,device=device, \n","                               test_dataloaders=test_dataloaders[:train_indexes+1])\n","    prev_guards.append(lll_object._precision_matrices)\n","    lll_object=rwalk(model=model, dataloader=train_dataloaders[train_indexes], epsilon=0.1, device=device, prev_guards=prev_guards)\n","    \n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","    rwalk_acc.extend(acc_list)\n","\n","    \n","print(rwalk_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["## &#x2728; SCP\n","Sliced Cramer Preservation\n","\n","参考论文:   \n","[Sliced Cramer Preservation](https://openreview.net/pdf?id=BJge3TNKwH)\n","\n","伪代码：  \n","\n","![scp](./HW14_pic/scp.png)"]},{"cell_type":"code","execution_count":21,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T16:09:27.125333Z","iopub.status.busy":"2023-07-19T16:09:27.124623Z","iopub.status.idle":"2023-07-19T16:09:27.141626Z","shell.execute_reply":"2023-07-19T16:09:27.140704Z","shell.execute_reply.started":"2023-07-19T16:09:27.125294Z"},"trusted":true},"outputs":[],"source":["\n","def sample_spherical(npoints, ndim=3):\n","    vec = np.random.randn(ndim, npoints)\n","    vec /= np.linalg.norm(vec, axis=0)\n","    return torch.from_numpy(vec)\n","\n","\n","class scp(object):\n","    \"\"\"\n","    OPEN REVIEW VERSION:\n","    https://openreview.net/forum?id=BJge3TNKwH\n","    \"\"\"\n","    def __init__(self, model: nn.Module, dataloader, L: int, device, prev_guards=[None]):\n","        self.model = model \n","        self.dataloader = dataloader\n","        self.params = {n: p for n, p in self.model.named_parameters() if p.requires_grad}\n","        self._state_parameters = {}\n","        self.L= L\n","        self.device = device\n","        self.previous_guards_list = prev_guards\n","        self._precision_matrices = self._calculate_importance()\n","        for n, p in self.params.items():\n","            self._state_parameters[n] = p.clone().detach()\n","    \n","    def _calculate_importance(self):\n","        out = {}\n","        # 初始化 Fisher (F) 矩阵（全部填充0）并加上之前的 guards\n","        for n, p in self.params.items():\n","            out[n] = p.clone().detach().fill_(0)\n","            for prev_guard in self.previous_guards_list:\n","                if prev_guard:\n","                    out[n] += prev_guard[n]\n","\n","        self.model.eval()\n","        if self.dataloader is not None:\n","            number_data = len(self.dataloader)                \n","            for x, y in self.dataloader:\n","                self.model.zero_grad()\n","                x, y = x.to(self.device), y.to(self.device)\n","                pred = self.model(x)\n","                \n","                mean_vec = pred.mean(dim=0)\n","                L_vectors = sample_spherical(self.L, pred.shape[-1])\n","                L_vectors = L_vectors.transpose(1, 0).to(self.device).float()\n","                \n","                total_scalar = 0\n","                for vec in L_vectors:\n","                    scalar = torch.matmul(vec, mean_vec)\n","                    total_scalar += scalar\n","                total_scalar /= L_vectors.shape[0] \n","                total_scalar.backward()         \n","\n","                for n, p in self.model.named_parameters():                                            \n","                    out[n].data += p.grad ** 2 / number_data\n","\n","                out = {n: p for n, p in out.items()}\n","        return out\n","\n","    def penalty(self, model: nn.Module):\n","        loss = 0\n","        for n, p in model.named_parameters():\n","            _loss = self._precision_matrices[n] * (p - self._state_parameters[n]) ** 2\n","            loss += _loss.sum()\n","        return loss\n","    \n","    def update(self, model):\n","        return "]},{"cell_type":"code","execution_count":22,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T16:09:27.143841Z","iopub.status.busy":"2023-07-19T16:09:27.142880Z","iopub.status.idle":"2023-07-19T16:43:58.201025Z","shell.execute_reply":"2023-07-19T16:43:58.199967Z","shell.execute_reply.started":"2023-07-19T16:09:27.143791Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["RUN SLICE CRAMER PRESERVATION\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"6c56b13015fd4123953b09e2565833b1","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/5 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["train_indexes=0\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=92.710 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=94.550 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.860 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=96.240 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=96.830 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=97.240 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=97.470 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=97.410 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=97.760 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=97.630 %\n","train_indexes=1\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=95.170 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=96.105 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=95.845 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=95.755 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=95.630 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=95.630 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=95.605 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=95.485 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=96.005 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=95.305 %\n","train_indexes=2\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=91.080 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=90.187 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=90.223 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=88.733 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=88.743 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=89.763 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=88.317 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=89.837 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=89.750 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=88.637 %\n","train_indexes=3\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=84.293 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=82.748 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=82.908 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=80.960 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=82.373 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=81.663 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=82.680 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=82.412 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=82.740 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=81.347 %\n","train_indexes=4\n"," --------------------------------------------------\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 01/10 ] acc=78.970 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 02/10 ] acc=77.020 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 03/10 ] acc=76.262 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 04/10 ] acc=76.008 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 05/10 ] acc=75.504 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 06/10 ] acc=76.706 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 07/10 ] acc=78.494 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 08/10 ] acc=77.724 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 09/10 ] acc=76.642 %\n"]},{"data":{"application/vnd.jupyter.widget-view+json":{"model_id":"","version_major":2,"version_minor":0},"text/plain":["  0%|          | 0/469 [00:00<?, ?it/s]"]},"metadata":{},"output_type":"display_data"},{"name":"stdout","output_type":"stream","text":["[ Val | Epoch 10/10 ] acc=76.710 %\n","[92.71000000000001, 94.55, 95.86, 96.24000000000001, 96.83, 97.24000000000001, 97.47, 97.41, 97.76, 97.63, 95.17, 96.10499999999999, 95.845, 95.755, 95.63000000000001, 95.63, 95.605, 95.485, 96.00500000000001, 95.30499999999999, 91.08000000000001, 90.18666666666667, 90.22333333333333, 88.73333333333333, 88.74333333333334, 89.76333333333332, 88.31666666666665, 89.83666666666666, 89.75, 88.63666666666667, 84.2925, 82.7475, 82.90750000000001, 80.96, 82.3725, 81.66250000000001, 82.67999999999999, 82.4125, 82.74000000000001, 81.3475, 78.97000000000001, 77.02, 76.262, 76.00800000000001, 75.50399999999999, 76.706, 78.49400000000001, 77.72400000000002, 76.642, 76.71]\n","==================================================================================================\n"]}],"source":["# SCP\n","print(\"RUN SLICE CRAMER PRESERVATION\")\n","model = Model()\n","model = model.to(device)\n","optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","\n","lll_object = scp(model=model, dataloader=None, L=100, device=device)\n","lll_lambda = 100\n","scp_acc = []\n","task_bar = tqdm(range(len(train_dataloaders)))\n","prev_guards = []\n","\n","for train_indexes in task_bar:\n","    task_bar.set_description(f\"Task  {train_indexes+1:02d}\")\n","    print(f'train_indexes={train_indexes}\\n', '--'*25)\n","    model, _, acc_list = train(model, optimizer, train_dataloaders[train_indexes], args.epochs_per_task, lll_object, lll_lambda, evaluate=evaluate,device=device, test_dataloaders=test_dataloaders[:train_indexes+1])\n","    prev_guards.append(lll_object._precision_matrices)\n","    lll_object=scp(model=model, dataloader=train_dataloaders[train_indexes], L=100, device=device, prev_guards=prev_guards)\n","    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n","    scp_acc.extend(acc_list)\n","\n","\n","print(scp_acc)\n","print(\"==================================================================================================\")"]},{"cell_type":"markdown","metadata":{},"source":["#  &#x1F4CC; 绘制不同终生学习`Long Life Machine Learning`算法序列任务学习的情况"]},{"cell_type":"code","execution_count":25,"metadata":{"execution":{"iopub.execute_input":"2023-07-19T16:49:51.359490Z","iopub.status.busy":"2023-07-19T16:49:51.359103Z","iopub.status.idle":"2023-07-19T16:49:51.897652Z","shell.execute_reply":"2023-07-19T16:49:51.896745Z","shell.execute_reply.started":"2023-07-19T16:49:51.359458Z"},"trusted":true},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1600x400 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["import matplotlib.pyplot as plt\n","\n","\n","def draw_acc(acc_list, label_list):\n","    plt.figure(figsize=(16, 4))\n","    for idx, (acc, label) in enumerate(zip(acc_list, label_list)):\n","        plt.plot(acc, marker='o', linestyle='--', linewidth=2, markersize=4, label=label)\n","        \n","    \n","    for idx, x in enumerate(range(0, len(acc_list[0]), 10)):\n","        plt.axvline(x=x, linestyle='--')\n","        plt.text(x=x+5, y=100, s=f\"TASK-{idx+1}\", ha='center')\n","    plt.savefig('acc_summary.png')\n","    plt.title('acc_summary')\n","    plt.ylim(60, 102)\n","    plt.ylabel('ACC')\n","    plt.legend()\n","    plt.show() \n","\n","\n","acc_list = [baseline_acc, ewc_acc, mas_acc, si_acc, rwalk_acc, scp_acc]\n","label_list = ['baseline', 'EWC', 'MAS', 'SI', 'RWALK', 'SCP']\n","# acc_list = [  mas_acc, si_acc, rwalk_acc, scp_acc]\n","# label_list = [  'MAS', 'SI', 'RWALK', 'SCP']\n","draw_acc(acc_list, label_list)"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.10.12"}},"nbformat":4,"nbformat_minor":4}
